/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is MPEG4IP.
 *
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
 *
 * Contributor(s):
 *      Dave Mackie     dmackie@cisco.com
 */

#include "src/impl.h"

namespace mp4v2
{
    namespace impl
    {

        ///////////////////////////////////////////////////////////////////////////////

        /* rtp hint track operations */

        MP4RtpHintTrack::MP4RtpHintTrack(MP4File &file, MP4Atom &trakAtom)
            : MP4Track(file, trakAtom)
        {
            m_pRefTrack = NULL;

            m_pRtpMapProperty = NULL;
            m_pPayloadNumberProperty = NULL;
            m_pMaxPacketSizeProperty = NULL;
            m_pSnroProperty = NULL;
            m_pTsroProperty = NULL;

            m_pReadHint = NULL;
            m_pReadHintSample = NULL;
            m_readHintSampleSize = 0;

            m_pWriteHint = NULL;
            m_writeHintId = MP4_INVALID_SAMPLE_ID;
            m_writePacketId = 0;

            m_pTrpy = NULL;
            m_pNump = NULL;
            m_pTpyl = NULL;
            m_pMaxr = NULL;
            m_pDmed = NULL;
            m_pDimm = NULL;
            m_pPmax = NULL;
            m_pDmax = NULL;

            m_pMaxPdu = NULL;
            m_pAvgPdu = NULL;
            m_pMaxBitRate = NULL;
            m_pAvgBitRate = NULL;

            m_thisSec = 0;
            m_bytesThisSec = 0;
            m_bytesThisHint = 0;
            m_bytesThisPacket = 0;
        }

        MP4RtpHintTrack::~MP4RtpHintTrack()
        {
            delete m_pReadHint;
            m_pReadHint = NULL;
            MP4Free( m_pReadHintSample );
            m_pReadHintSample = NULL;
            delete m_pWriteHint;
            m_pWriteHint = NULL;
        }

        void MP4RtpHintTrack::InitRefTrack()
        {
            if (m_pRefTrack == NULL)
            {
                MP4Integer32Property *pRefTrackIdProperty = NULL;
                (void)m_trakAtom.FindProperty(
                    "trak.tref.hint.entries[0].trackId",
                    (MP4Property **)&pRefTrackIdProperty);
                ASSERT(pRefTrackIdProperty);

                m_pRefTrack = m_File.GetTrack(pRefTrackIdProperty->GetValue());
            }
        }

        void MP4RtpHintTrack::InitRtpStart()
        {
            number::srandom( time::getLocalTimeMilliseconds() );

            (void)m_trakAtom.FindProperty(
                "trak.udta.hnti.rtp .snro.offset",
                (MP4Property **)&m_pSnroProperty);

            if (m_pSnroProperty)
            {
                m_rtpSequenceStart = m_pSnroProperty->GetValue();
            }
            else
            {
                m_rtpSequenceStart = number::random32();
            }

            (void)m_trakAtom.FindProperty(
                "trak.udta.hnti.rtp .tsro.offset",
                (MP4Property **)&m_pTsroProperty);

            if (m_pTsroProperty)
            {
                m_rtpTimestampStart = m_pTsroProperty->GetValue();
            }
            else
            {
                m_rtpTimestampStart = number::random32();
            }
        }

        void MP4RtpHintTrack::ReadHint(
            MP4SampleId hintSampleId,
            uint16_t *pNumPackets)
        {
            if (m_pRefTrack == NULL)
            {
                InitRefTrack();
                InitRtpStart();
            }

            // dispose of any old hint
            delete m_pReadHint;
            m_pReadHint = NULL;
            MP4Free( m_pReadHintSample );
            m_pReadHintSample = NULL;
            m_readHintSampleSize = 0;

            // read the desired hint sample into memory
            ReadSample(
                hintSampleId,
                &m_pReadHintSample,
                &m_readHintSampleSize,
                &m_readHintTimestamp);

            m_File.EnableMemoryBuffer(m_pReadHintSample, m_readHintSampleSize);

            m_pReadHint = new MP4RtpHint(*this);
            m_pReadHint->Read(m_File);

            m_File.DisableMemoryBuffer();

            if (pNumPackets)
            {
                *pNumPackets = GetHintNumberOfPackets();
            }
        }

        uint16_t MP4RtpHintTrack::GetHintNumberOfPackets()
        {
            if (m_pReadHint == NULL)
            {
                throw new Exception("no hint has been read",
                                    __FILE__, __LINE__, __FUNCTION__);
            }
            return m_pReadHint->GetNumberOfPackets();
        }

        bool MP4RtpHintTrack::GetPacketBFrame(uint16_t packetIndex)
        {
            if (m_pReadHint == NULL)
            {
                throw new Exception("no hint has been read",
                                    __FILE__, __LINE__, __FUNCTION__);
            }
            MP4RtpPacket *pPacket =
                m_pReadHint->GetPacket(packetIndex);

            return pPacket->IsBFrame();
        }

        uint16_t MP4RtpHintTrack::GetPacketTransmitOffset(uint16_t packetIndex)
        {
            if (m_pReadHint == NULL)
            {
                throw new Exception("no hint has been read",
                                    __FILE__, __LINE__, __FUNCTION__);
            }

            MP4RtpPacket *pPacket =
                m_pReadHint->GetPacket(packetIndex);

            return pPacket->GetTransmitOffset();
        }

        void MP4RtpHintTrack::ReadPacket(
            uint16_t packetIndex,
            uint8_t **ppBytes,
            uint32_t *pNumBytes,
            uint32_t ssrc,
            bool addHeader,
            bool addPayload)
        {
            if (m_pReadHint == NULL)
            {
                throw new Exception("no hint has been read",
                                    __FILE__, __LINE__, __FUNCTION__);
            }
            if (!addHeader && !addPayload)
            {
                throw new Exception("no data requested",
                                    __FILE__, __LINE__, __FUNCTION__);
            }

            MP4RtpPacket *pPacket =
                m_pReadHint->GetPacket(packetIndex);

            *pNumBytes = 0;
            if (addHeader)
            {
                *pNumBytes += 12;
            }
            if (addPayload)
            {
                *pNumBytes += pPacket->GetDataSize();
            }

            // if needed, allocate the packet memory
            bool buffer_malloc = false;

            if (*ppBytes == NULL)
            {
                *ppBytes = (uint8_t *)MP4Malloc(*pNumBytes);
                buffer_malloc = true;
            }

            try
            {
                uint8_t *pDest = *ppBytes;

                if (addHeader)
                {
                    *pDest++ =
                        0x80 | (pPacket->GetPBit() << 5) | (pPacket->GetXBit() << 4);

                    *pDest++ =
                        (pPacket->GetMBit() << 7) | pPacket->GetPayload();

                    *((uint16_t *)pDest) =
                        MP4V2_HTONS(m_rtpSequenceStart + pPacket->GetSequenceNumber());
                    pDest += 2;

                    *((uint32_t *)pDest) =
                        MP4V2_HTONL(m_rtpTimestampStart + (uint32_t)m_readHintTimestamp);
                    pDest += 4;

                    *((uint32_t *)pDest) =
                        MP4V2_HTONL(ssrc);
                    pDest += 4;
                }

                if (addPayload)
                {
                    pPacket->GetData(pDest);
                }
            }
            catch (Exception *x)
            {
                if (buffer_malloc)
                {
                    MP4Free(*ppBytes);
                    *ppBytes = NULL;
                }
                throw x;
            }

            log.hexDump(0, MP4_LOG_VERBOSE1, *ppBytes, *pNumBytes,
                        "\"%s\": %u ", GetFile().GetFilename().c_str(),
                        packetIndex);
        }

        MP4Timestamp MP4RtpHintTrack::GetRtpTimestampStart()
        {
            if (m_pRefTrack == NULL)
            {
                InitRefTrack();
                InitRtpStart();
            }

            return m_rtpTimestampStart;
        }

        void MP4RtpHintTrack::SetRtpTimestampStart(MP4Timestamp start)
        {
            if (!m_pTsroProperty)
            {
                MP4Atom *pTsroAtom =
                    m_File.AddDescendantAtoms(&m_trakAtom, "udta.hnti.rtp .tsro");

                ASSERT(pTsroAtom);

                (void)pTsroAtom->FindProperty("offset",
                                              (MP4Property **)&m_pTsroProperty);

                ASSERT(m_pTsroProperty);
            }

            m_pTsroProperty->SetValue(start);
            m_rtpTimestampStart = start;
        }

        void MP4RtpHintTrack::InitPayload()
        {
            if (m_pRtpMapProperty == NULL)
            {
                (void)m_trakAtom.FindProperty(
                    "trak.udta.hinf.payt.rtpMap",
                    (MP4Property **)&m_pRtpMapProperty);
            }

            if (m_pPayloadNumberProperty == NULL)
            {
                (void)m_trakAtom.FindProperty(
                    "trak.udta.hinf.payt.payloadNumber",
                    (MP4Property **)&m_pPayloadNumberProperty);
            }

            if (m_pMaxPacketSizeProperty == NULL)
            {
                (void)m_trakAtom.FindProperty(
                    "trak.mdia.minf.stbl.stsd.rtp .maxPacketSize",
                    (MP4Property **)&m_pMaxPacketSizeProperty);
            }
        }

        void MP4RtpHintTrack::GetPayload(
            char **ppPayloadName,
            uint8_t *pPayloadNumber,
            uint16_t *pMaxPayloadSize,
            char **ppEncodingParams)
        {
            const char *pRtpMap;
            const char *pSlash;
            uint32_t length;
            InitPayload();

            if (ppPayloadName || ppEncodingParams)
            {
                if (ppPayloadName)
                    *ppPayloadName = NULL;
                if (ppEncodingParams)
                    *ppEncodingParams = NULL;
                if (m_pRtpMapProperty)
                {
                    pRtpMap = m_pRtpMapProperty->GetValue();
                    pSlash = strchr(pRtpMap, '/');

                    if (pSlash)
                    {
                        length = pSlash - pRtpMap;
                    }
                    else
                    {
                        length = (uint32_t)strlen(pRtpMap);
                    }

                    if (ppPayloadName)
                    {
                        *ppPayloadName = (char *)MP4Calloc(length + 1);
                        strncpy(*ppPayloadName, pRtpMap, length);
                    }
                    if (pSlash && ppEncodingParams)
                    {
                        pSlash++;
                        pSlash = strchr(pSlash, '/');
                        if (pSlash != NULL)
                        {
                            pSlash++;
                            if (pSlash != 0)
                            {
                                length = (uint32_t)strlen(pRtpMap) - (pSlash - pRtpMap);
                                *ppEncodingParams = (char *)MP4Calloc(length + 1);
                                strncpy(*ppEncodingParams, pSlash, length);
                            }
                        }
                    }
                }
            }

            if (pPayloadNumber)
            {
                if (m_pPayloadNumberProperty)
                {
                    *pPayloadNumber = m_pPayloadNumberProperty->GetValue();
                }
                else
                {
                    *pPayloadNumber = 0;
                }
            }

            if (pMaxPayloadSize)
            {
                if (m_pMaxPacketSizeProperty)
                {
                    *pMaxPayloadSize = m_pMaxPacketSizeProperty->GetValue();
                }
                else
                {
                    *pMaxPayloadSize = 0;
                }
            }
        }

        void MP4RtpHintTrack::SetPayload(
            const char *payloadName,
            uint8_t payloadNumber,
            uint16_t maxPayloadSize,
            const char *encoding_parms,
            bool include_rtp_map,
            bool include_mpeg4_esid)
        {
            InitRefTrack();
            InitPayload();

            ASSERT(m_pRtpMapProperty);
            ASSERT(m_pPayloadNumberProperty);
            ASSERT(m_pMaxPacketSizeProperty);

            size_t len = strlen(payloadName) + 16;
            if (encoding_parms != NULL)
            {
                size_t temp = strlen(encoding_parms);
                if (temp == 0)
                {
                    encoding_parms = NULL;
                }
                else
                {
                    len += temp;
                }
            }

            char *rtpMapBuf = (char *)MP4Malloc(len);
            snprintf(rtpMapBuf, len, "%s/%u%c%s",
                     payloadName,
                     GetTimeScale(),
                     encoding_parms != NULL ? '/' : '\0',
                     encoding_parms == NULL ? "" : encoding_parms);
            m_pRtpMapProperty->SetValue(rtpMapBuf);

            m_pPayloadNumberProperty->SetValue(payloadNumber);

            if (maxPayloadSize == 0)
            {
                maxPayloadSize = 1460;
            }
            m_pMaxPacketSizeProperty->SetValue(maxPayloadSize);

            // set sdp media type
            const char *sdpMediaType;
            if (!strcmp(m_pRefTrack->GetType(), MP4_AUDIO_TRACK_TYPE))
            {
                sdpMediaType = "audio";
            }
            else if (!strcmp(m_pRefTrack->GetType(), MP4_VIDEO_TRACK_TYPE))
            {
                sdpMediaType = "video";
            }
            else if (!strcmp(m_pRefTrack->GetType(), MP4_CNTL_TRACK_TYPE))
            {
                sdpMediaType = "control";
            }
            else
            {
                sdpMediaType = "application";
            }

            uint32_t maxlen =
                (uint32_t)strlen(sdpMediaType) + (uint32_t)strlen(rtpMapBuf) + 256;
            char *sdpBuf = (char *)MP4Malloc(maxlen);
            uint32_t buflen;
            buflen = snprintf(sdpBuf, maxlen,
                              "m=%s 0 RTP/AVP %u\015\012"
                              "a=control:trackID=%u\015\012",
                              sdpMediaType, payloadNumber,
                              m_trackId);
            if (include_rtp_map)
            {
                buflen += snprintf(sdpBuf + buflen, maxlen - buflen,
                                   "a=rtpmap:%u %s\015\012",
                                   payloadNumber, rtpMapBuf);
            }
            if (include_mpeg4_esid)
            {
                snprintf(sdpBuf + buflen, maxlen - buflen,
                         "a=mpeg4-esid:%u\015\012",
                         m_pRefTrack->GetId());
            }

            MP4StringProperty *pSdpProperty = NULL;
            (void)m_trakAtom.FindProperty("trak.udta.hnti.sdp .sdpText",
                                          (MP4Property **)&pSdpProperty);
            ASSERT(pSdpProperty);
            pSdpProperty->SetValue(sdpBuf);

            // cleanup
            MP4Free(rtpMapBuf);
            MP4Free(sdpBuf);
        }

        void MP4RtpHintTrack::AddHint(bool isBFrame, uint32_t timestampOffset)
        {
            // on first hint, need to lookup the reference track
            if (m_writeHintId == MP4_INVALID_SAMPLE_ID)
            {
                InitRefTrack();
                InitStats();
            }

            if (m_pWriteHint)
            {
                throw new Exception("unwritten hint is still pending", __FILE__, __LINE__, __FUNCTION__);
            }

            m_pWriteHint = new MP4RtpHint(*this);
            m_pWriteHint->SetBFrame(isBFrame);
            m_pWriteHint->SetTimestampOffset(timestampOffset);

            m_bytesThisHint = 0;
            m_writeHintId++;
        }

        void MP4RtpHintTrack::AddPacket(bool setMbit, int32_t transmitOffset)
        {
            if (m_pWriteHint == NULL)
            {
                throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__);
            }

            MP4RtpPacket *pPacket = m_pWriteHint->AddPacket();

            ASSERT(m_pPayloadNumberProperty);

            pPacket->Set(
                m_pPayloadNumberProperty->GetValue(),
                m_writePacketId++,
                setMbit);
            pPacket->SetTransmitOffset(transmitOffset);

            m_bytesThisHint += 12;
            if (m_bytesThisPacket > m_pPmax->GetValue())
            {
                m_pPmax->SetValue(m_bytesThisPacket);
            }
            m_bytesThisPacket = 12;
            m_pNump->IncrementValue();
            m_pTrpy->IncrementValue(12); // RTP packet header size
        }

        void MP4RtpHintTrack::AddImmediateData(
            const uint8_t *pBytes,
            uint32_t numBytes)
        {
            if (m_pWriteHint == NULL)
            {
                throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
            }

            MP4RtpPacket *pPacket = m_pWriteHint->GetCurrentPacket();
            if (pPacket == NULL)
            {
                throw new Exception("no packet pending", __FILE__, __LINE__, __FUNCTION__);
            }

            if (pBytes == NULL || numBytes == 0)
            {
                throw new Exception("no data",
                                    __FILE__, __LINE__, __FUNCTION__ );
            }
            if (numBytes > 14)
            {
                throw new Exception("data size is larger than 14 bytes",
                                    __FILE__, __LINE__, __FUNCTION__ );
            }

            MP4RtpImmediateData *pData = new MP4RtpImmediateData(*pPacket);
            pData->Set(pBytes, numBytes);

            pPacket->AddData(pData);

            m_bytesThisHint += numBytes;
            m_bytesThisPacket += numBytes;
            m_pDimm->IncrementValue(numBytes);
            m_pTpyl->IncrementValue(numBytes);
            m_pTrpy->IncrementValue(numBytes);
        }

        void MP4RtpHintTrack::AddSampleData(
            MP4SampleId sampleId,
            uint32_t dataOffset,
            uint32_t dataLength)
        {
            if (m_pWriteHint == NULL)
            {
                throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
            }

            MP4RtpPacket *pPacket = m_pWriteHint->GetCurrentPacket();
            if (pPacket == NULL)
            {
                throw new Exception("no packet pending", __FILE__, __LINE__, __FUNCTION__ );
            }

            MP4RtpSampleData *pData = new MP4RtpSampleData(*pPacket);

            pData->SetReferenceSample(sampleId, dataOffset, dataLength);

            pPacket->AddData(pData);

            m_bytesThisHint += dataLength;
            m_bytesThisPacket += dataLength;
            m_pDmed->IncrementValue(dataLength);
            m_pTpyl->IncrementValue(dataLength);
            m_pTrpy->IncrementValue(dataLength);
        }

        void MP4RtpHintTrack::AddESConfigurationPacket()
        {
            if (m_pWriteHint == NULL)
            {
                throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
            }

            uint8_t *pConfig = NULL;
            uint32_t configSize = 0;

            m_File.GetTrackESConfiguration(m_pRefTrack->GetId(),
                                           &pConfig, &configSize);

            if (pConfig == NULL)
            {
                return;
            }

            ASSERT(m_pMaxPacketSizeProperty);

            if (configSize > m_pMaxPacketSizeProperty->GetValue())
            {
                throw new Exception("ES configuration is too large for RTP payload", __FILE__, __LINE__, __FUNCTION__ );
            }

            AddPacket(false);

            MP4RtpPacket *pPacket = m_pWriteHint->GetCurrentPacket();
            ASSERT(pPacket);

            // This is ugly!
            // To get the ES configuration data somewhere known
            // we create a sample data reference that points to
            // this hint track (not the media track)
            // and this sample of the hint track
            // the offset into this sample is filled in during the write process
            MP4RtpSampleData *pData = new MP4RtpSampleData(*pPacket);

            pData->SetEmbeddedImmediate(m_writeSampleId, pConfig, configSize);

            pPacket->AddData(pData);

            m_bytesThisHint += configSize;
            m_bytesThisPacket += configSize;
            m_pTpyl->IncrementValue(configSize);
            m_pTrpy->IncrementValue(configSize);
        }

        void MP4RtpHintTrack::WriteHint(MP4Duration duration, bool isSyncSample)
        {
            if (m_pWriteHint == NULL)
            {
                throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ );
            }

            uint8_t *pBytes;
            uint64_t numBytes;

            m_File.EnableMemoryBuffer();

            m_pWriteHint->Write(m_File);

            m_File.DisableMemoryBuffer(&pBytes, &numBytes);

            WriteSample(pBytes, numBytes, duration, 0, isSyncSample);

            MP4Free(pBytes);

            // update statistics
            if (m_bytesThisPacket > m_pPmax->GetValue())
            {
                m_pPmax->SetValue(m_bytesThisPacket);
            }

            if (duration > m_pDmax->GetValue())
            {
                m_pDmax->SetValue(duration);
            }

            MP4Timestamp startTime;

            GetSampleTimes(m_writeHintId, &startTime, NULL);

            if (startTime < m_thisSec + GetTimeScale())
            {
                m_bytesThisSec += m_bytesThisHint;
            }
            else
            {
                if (m_bytesThisSec > m_pMaxr->GetValue())
                {
                    m_pMaxr->SetValue(m_bytesThisSec);
                }
                m_thisSec = startTime - (startTime % GetTimeScale());
                m_bytesThisSec = m_bytesThisHint;
            }

            // cleanup
            delete m_pWriteHint;
            m_pWriteHint = NULL;
        }

        void MP4RtpHintTrack::FinishWrite(uint32_t option)
        {
            if (m_writeHintId != MP4_INVALID_SAMPLE_ID)
            {
                m_pMaxPdu->SetValue(m_pPmax->GetValue());
                if (m_pNump->GetValue())
                {
                    m_pAvgPdu->SetValue(m_pTrpy->GetValue() / m_pNump->GetValue());
                }

                m_pMaxBitRate->SetValue(m_pMaxr->GetValue() * 8);
                if (GetDuration())
                {
                    m_pAvgBitRate->SetValue(
                        m_pTrpy->GetValue() * 8 * GetTimeScale() / GetDuration());
                }
            }

            MP4Track::FinishWrite();
        }

        void MP4RtpHintTrack::InitStats()
        {
            MP4Atom *pHinfAtom = m_trakAtom.FindAtom("trak.udta.hinf");

            ASSERT(pHinfAtom);

            (void)pHinfAtom->FindProperty("hinf.trpy.bytes", (MP4Property **)&m_pTrpy);
            (void)pHinfAtom->FindProperty("hinf.nump.packets", (MP4Property **)&m_pNump);
            (void)pHinfAtom->FindProperty("hinf.tpyl.bytes", (MP4Property **)&m_pTpyl);
            (void)pHinfAtom->FindProperty("hinf.maxr.bytes", (MP4Property **)&m_pMaxr);
            (void)pHinfAtom->FindProperty("hinf.dmed.bytes", (MP4Property **)&m_pDmed);
            (void)pHinfAtom->FindProperty("hinf.dimm.bytes", (MP4Property **)&m_pDimm);
            (void)pHinfAtom->FindProperty("hinf.pmax.bytes", (MP4Property **)&m_pPmax);
            (void)pHinfAtom->FindProperty("hinf.dmax.milliSecs", (MP4Property **)&m_pDmax);

            MP4Atom *pHmhdAtom = m_trakAtom.FindAtom("trak.mdia.minf.hmhd");

            ASSERT(pHmhdAtom);

            (void)pHmhdAtom->FindProperty("hmhd.maxPduSize", (MP4Property **)&m_pMaxPdu);
            (void)pHmhdAtom->FindProperty("hmhd.avgPduSize", (MP4Property **)&m_pAvgPdu);
            (void)pHmhdAtom->FindProperty("hmhd.maxBitRate", (MP4Property **)&m_pMaxBitRate);
            (void)pHmhdAtom->FindProperty("hmhd.avgBitRate", (MP4Property **)&m_pAvgBitRate);

            MP4Integer32Property *pMaxrPeriod = NULL;
            (void)pHinfAtom->FindProperty("hinf.maxr.granularity",
                                          (MP4Property **)&pMaxrPeriod);
            if (pMaxrPeriod)
            {
                pMaxrPeriod->SetValue(1000);    // 1 second
            }
        }


        MP4RtpHint::MP4RtpHint(MP4RtpHintTrack &track)
            : m_track(track)
        {
            AddProperty( /* 0 */
                new MP4Integer16Property(this->GetTrack().GetTrakAtom(), "packetCount"));
            AddProperty( /* 1 */
                new MP4Integer16Property(this->GetTrack().GetTrakAtom(), "reserved"));
        }

        MP4RtpHint::~MP4RtpHint()
        {
            for (uint32_t i = 0; i < m_rtpPackets.Size(); i++)
            {
                delete m_rtpPackets[i];
            }
        }

        MP4RtpPacket *MP4RtpHint::AddPacket()
        {
            MP4RtpPacket *pPacket = new MP4RtpPacket(*this);
            m_rtpPackets.Add(pPacket);

            // packetCount property
            ((MP4Integer16Property *)m_pProperties[0])->IncrementValue();

            pPacket->SetBFrame(m_isBFrame);
            pPacket->SetTimestampOffset(m_timestampOffset);

            return pPacket;
        }

        void MP4RtpHint::Read(MP4File &file)
        {
            // call base class Read for required properties
            MP4Container::Read(file);

            uint16_t numPackets =
                ((MP4Integer16Property *)m_pProperties[0])->GetValue();

            for (uint16_t i = 0; i < numPackets; i++)
            {
                MP4RtpPacket *pPacket = new MP4RtpPacket(*this);

                m_rtpPackets.Add(pPacket);

                pPacket->Read(file);
            }

            if (log.verbosity >= MP4_LOG_VERBOSE1)
            {
                log.verbose1f("\"%s\": ReadHint:", GetTrack().GetFile().GetFilename().c_str());
                Dump(10, false);
            }
        }

        void MP4RtpHint::Write(MP4File &file)
        {
            uint64_t hintStartPos = file.GetPosition();

            MP4Container::Write(file);

            uint64_t packetStartPos = file.GetPosition();

            uint32_t i;

            // first write out packet (and data) entries
            for (i = 0; i < m_rtpPackets.Size(); i++)
            {
                m_rtpPackets[i]->Write(file);
            }

            // now let packets write their extra data into the hint sample
            for (i = 0; i < m_rtpPackets.Size(); i++)
            {
                m_rtpPackets[i]->WriteEmbeddedData(file, hintStartPos);
            }

            uint64_t endPos = file.GetPosition();

            file.SetPosition(packetStartPos);

            // finally rewrite the packet and data entries
            // which now contain the correct offsets for the embedded data
            for (i = 0; i < m_rtpPackets.Size(); i++)
            {
                m_rtpPackets[i]->Write(file);
            }

            file.SetPosition(endPos);

            if (log.verbosity >= MP4_LOG_VERBOSE1)
            {
                log.verbose1f("\"%s\": WriteRtpHint:", GetTrack().GetFile().GetFilename().c_str());
                Dump(14, false);
            }
        }

        void MP4RtpHint::Dump(uint8_t indent, bool dumpImplicits)
        {
            MP4Container::Dump(indent, dumpImplicits);

            for (uint32_t i = 0; i < m_rtpPackets.Size(); i++)
            {
                log.dump(indent, MP4_LOG_VERBOSE1, "\"%s\": RtpPacket: %u",
                         GetTrack().GetFile().GetFilename().c_str(), i);
                m_rtpPackets[i]->Dump(indent + 1, dumpImplicits);
            }
        }

        MP4RtpPacket::MP4RtpPacket(MP4RtpHint &hint)
            : m_hint(hint)
        {
            AddProperty( /* 0 */
                new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "relativeXmitTime"));
            AddProperty( /* 1 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved1", 2));
            AddProperty( /* 2 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Pbit", 1));
            AddProperty( /* 3 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Xbit", 1));
            AddProperty( /* 4 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved2", 4));
            AddProperty( /* 5 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Mbit", 1));
            AddProperty( /* 6 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "payloadType", 7));
            AddProperty( /* 7  */
                new MP4Integer16Property(this->GetHint().GetTrack().GetTrakAtom(), "sequenceNumber"));
            AddProperty( /* 8 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved3", 13));
            AddProperty( /* 9 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "extraFlag", 1));
            AddProperty( /* 10 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "bFrameFlag", 1));
            AddProperty( /* 11 */
                new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "repeatFlag", 1));
            AddProperty( /* 12 */
                new MP4Integer16Property(this->GetHint().GetTrack().GetTrakAtom(), "entryCount"));
        }

        MP4RtpPacket::~MP4RtpPacket()
        {
            for (uint32_t i = 0; i < m_rtpData.Size(); i++)
            {
                delete m_rtpData[i];
            }
        }

        void MP4RtpPacket::AddExtraProperties()
        {
            AddProperty( /* 13 */
                new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "extraInformationLength"));

            // This is a bit of a hack, since the tlv entries are really defined
            // as atoms but there is only one type defined now, rtpo, and getting
            // our atom code hooked up here would be a major pain with little gain

            AddProperty( /* 14 */
                new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "tlvLength"));
            AddProperty( /* 15 */
                new MP4StringProperty(this->GetHint().GetTrack().GetTrakAtom(), "tlvType"));
            AddProperty( /* 16 */
                new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "timestampOffset"));

            ((MP4Integer32Property *)m_pProperties[13])->SetValue(16);
            ((MP4Integer32Property *)m_pProperties[14])->SetValue(12);
            ((MP4StringProperty *)m_pProperties[15])->SetFixedLength(4);
            ((MP4StringProperty *)m_pProperties[15])->SetValue("rtpo");
        }

        void MP4RtpPacket::Read(MP4File &file)
        {
            // call base class Read for required properties
            MP4Container::Read(file);

            // read extra info if present
            // we only support the rtpo field!
            if (((MP4BitfieldProperty *)m_pProperties[9])->GetValue() == 1)
            {
                ReadExtra(file);
            }

            uint16_t numDataEntries =
                ((MP4Integer16Property *)m_pProperties[12])->GetValue();

            // read data entries
            for (uint16_t i = 0; i < numDataEntries; i++)
            {
                uint8_t dataType;
                file.PeekBytes(&dataType, 1);

                MP4RtpData *pData;

                switch (dataType)
                {
                case 0:
                    pData = new MP4RtpNullData(*this);
                    break;
                case 1:
                    pData = new MP4RtpImmediateData(*this);
                    break;
                case 2:
                    pData = new MP4RtpSampleData(*this);
                    break;
                case 3:
                    pData = new MP4RtpSampleDescriptionData(*this);
                    break;
                default:
                    throw new Exception("unknown packet data entry type", __FILE__, __LINE__, __FUNCTION__ );
                }

                m_rtpData.Add(pData);

                // read data entry's properties
                pData->Read(file);
            }
        }

        void MP4RtpPacket::ReadExtra(MP4File &file)
        {
            AddExtraProperties();

            int32_t extraLength = (int32_t)file.ReadUInt32();

            if (extraLength < 4)
            {
                throw new Exception("bad packet extra info length", __FILE__, __LINE__, __FUNCTION__ );
            }
            extraLength -= 4;

            while (extraLength > 0)
            {
                uint32_t entryLength = file.ReadUInt32();
                uint32_t entryTag = file.ReadUInt32();

                if (entryLength < 8)
                {
                    throw new Exception("bad packet extra info entry length", __FILE__, __LINE__, __FUNCTION__ );
                }

                if (entryTag == STRTOINT32("rtpo") && entryLength == 12)
                {
                    // read the rtp timestamp offset
                    m_pProperties[16]->Read(file);
                }
                else
                {
                    // ignore it, LATER carry it along
                    file.SetPosition(file.GetPosition() + entryLength - 8);
                }

                extraLength -= entryLength;
            }

            if (extraLength < 0)
            {
                throw new Exception("invalid packet extra info length", __FILE__, __LINE__, __FUNCTION__ );
            }
        }

        void MP4RtpPacket::Set(uint8_t payloadNumber,
                               uint32_t packetId, bool setMbit)
        {
            ((MP4BitfieldProperty *)m_pProperties[5])->SetValue(setMbit);
            ((MP4BitfieldProperty *)m_pProperties[6])->SetValue(payloadNumber);
            ((MP4Integer16Property *)m_pProperties[7])->SetValue(packetId);
        }

        int32_t MP4RtpPacket::GetTransmitOffset()
        {
            return ((MP4Integer32Property *)m_pProperties[0])->GetValue();
        }

        void MP4RtpPacket::SetTransmitOffset(int32_t transmitOffset)
        {
            ((MP4Integer32Property *)m_pProperties[0])->SetValue(transmitOffset);
        }

        bool MP4RtpPacket::GetPBit()
        {
            return ((MP4BitfieldProperty *)m_pProperties[2])->GetValue();
        }

        bool MP4RtpPacket::GetXBit()
        {
            return ((MP4BitfieldProperty *)m_pProperties[3])->GetValue();
        }

        bool MP4RtpPacket::GetMBit()
        {
            return ((MP4BitfieldProperty *)m_pProperties[5])->GetValue();
        }

        uint8_t MP4RtpPacket::GetPayload()
        {
            return ((MP4BitfieldProperty *)m_pProperties[6])->GetValue();
        }

        uint16_t MP4RtpPacket::GetSequenceNumber()
        {
            return ((MP4Integer16Property *)m_pProperties[7])->GetValue();
        }

        bool MP4RtpPacket::IsBFrame()
        {
            return ((MP4BitfieldProperty *)m_pProperties[10])->GetValue();
        }

        void MP4RtpPacket::SetBFrame(bool isBFrame)
        {
            ((MP4BitfieldProperty *)m_pProperties[10])->SetValue(isBFrame);
        }

        void MP4RtpPacket::SetTimestampOffset(uint32_t timestampOffset)
        {
            if (timestampOffset == 0)
            {
                return;
            }

            ASSERT(((MP4BitfieldProperty *)m_pProperties[9])->GetValue() == 0);

            // set X bit
            ((MP4BitfieldProperty *)m_pProperties[9])->SetValue(1);

            AddExtraProperties();

            ((MP4Integer32Property *)m_pProperties[16])->SetValue(timestampOffset);
        }

        void MP4RtpPacket::AddData(MP4RtpData *pData)
        {
            m_rtpData.Add(pData);

            // increment entry count property
            ((MP4Integer16Property *)m_pProperties[12])->IncrementValue();
        }

        uint32_t MP4RtpPacket::GetDataSize()
        {
            uint32_t totalDataSize = 0;

            for (uint32_t i = 0; i < m_rtpData.Size(); i++)
            {
                totalDataSize += m_rtpData[i]->GetDataSize();
            }

            return totalDataSize;
        }

        void MP4RtpPacket::GetData(uint8_t *pDest)
        {
            for (uint32_t i = 0; i < m_rtpData.Size(); i++)
            {
                m_rtpData[i]->GetData(pDest);
                pDest += m_rtpData[i]->GetDataSize();
            }
        }

        void MP4RtpPacket::Write(MP4File &file)
        {
            MP4Container::Write(file);

            for (uint32_t i = 0; i < m_rtpData.Size(); i++)
            {
                m_rtpData[i]->Write(file);
            }
        }

        void MP4RtpPacket::WriteEmbeddedData(MP4File &file, uint64_t startPos)
        {
            for (uint32_t i = 0; i < m_rtpData.Size(); i++)
            {
                m_rtpData[i]->WriteEmbeddedData(file, startPos);
            }
        }

        void MP4RtpPacket::Dump(uint8_t indent, bool dumpImplicits)
        {
            MP4Container::Dump(indent, dumpImplicits);

            for (uint32_t i = 0; i < m_rtpData.Size(); i++)
            {
                log.dump(indent, MP4_LOG_VERBOSE1, "\"%s\": RtpData: %u",
                         GetHint().GetTrack().GetFile().GetFilename().c_str(), i);
                m_rtpData[i]->Dump(indent + 1, dumpImplicits);
            }
        }

        MP4RtpData::MP4RtpData(MP4RtpPacket &packet)
            : m_packet(packet)
        {
            AddProperty( /* 0 */
                new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "type"));
        }

        MP4Track *MP4RtpData::FindTrackFromRefIndex(uint8_t refIndex)
        {
            MP4Track *pTrack;

            if (refIndex == (uint8_t) - 1)
            {
                // ourselves
                pTrack = &GetPacket().GetHint().GetTrack();
            }
            else if (refIndex == 0)
            {
                // our reference track
                pTrack = GetPacket().GetHint().GetTrack().GetRefTrack();
            }
            else
            {
                // some other track
                MP4RtpHintTrack *pHintTrack =
                    &GetPacket().GetHint().GetTrack();

                MP4Atom &trakAtom = pHintTrack->GetTrakAtom();

                MP4Integer32Property *pTrackIdProperty = NULL;
                (void)trakAtom.FindProperty(
                    "trak.tref.hint.entries",
                    (MP4Property **)&pTrackIdProperty);
                ASSERT(pTrackIdProperty);

                uint32_t refTrackId =
                    pTrackIdProperty->GetValue(refIndex - 1);

                pTrack = pHintTrack->GetFile().GetTrack(refTrackId);
            }

            return pTrack;
        }

        MP4RtpNullData::MP4RtpNullData(MP4RtpPacket &packet)
            : MP4RtpData(packet)
        {
            ((MP4Integer8Property *)m_pProperties[0])->SetValue(0);

            AddProperty( /* 1 */
                new MP4BytesProperty(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "pad", 15));

            ((MP4BytesProperty *)m_pProperties[1])->SetFixedSize(15);
        }

        MP4RtpImmediateData::MP4RtpImmediateData(MP4RtpPacket &packet)
            : MP4RtpData(packet)
        {
            ((MP4Integer8Property *)m_pProperties[0])->SetValue(1);

            AddProperty( /* 1 */
                new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "count"));
            AddProperty( /* 2 */
                new MP4BytesProperty(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "data", 14));

            ((MP4BytesProperty *)m_pProperties[2])->SetFixedSize(14);
        }

        void MP4RtpImmediateData::Set(const uint8_t *pBytes, uint8_t numBytes)
        {
            ((MP4Integer8Property *)m_pProperties[1])->SetValue(numBytes);
            ((MP4BytesProperty *)m_pProperties[2])->SetValue(pBytes, numBytes);
        }

        uint16_t MP4RtpImmediateData::GetDataSize()
        {
            return ((MP4Integer8Property *)m_pProperties[1])->GetValue();
        }

        void MP4RtpImmediateData::GetData(uint8_t *pDest)
        {
            uint8_t *pValue;
            uint32_t valueSize;
            ((MP4BytesProperty *)m_pProperties[2])->GetValue(&pValue, &valueSize);

            memcpy(pDest, pValue, GetDataSize());
            MP4Free(pValue);
        }

        MP4RtpSampleData::MP4RtpSampleData(MP4RtpPacket &packet)
            : MP4RtpData(packet)
        {
            ((MP4Integer8Property *)m_pProperties[0])->SetValue(2);

            AddProperty( /* 1 */
                new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "trackRefIndex"));
            AddProperty( /* 2 */
                new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "length"));
            AddProperty( /* 3 */
                new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleNumber"));
            AddProperty( /* 4 */
                new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleOffset"));
            AddProperty( /* 5 */
                new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "bytesPerBlock"));
            AddProperty( /* 6 */
                new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "samplesPerBlock"));

            ((MP4Integer16Property *)m_pProperties[5])->SetValue(1);
            ((MP4Integer16Property *)m_pProperties[6])->SetValue(1);

            m_pRefData = NULL;
            m_pRefTrack = NULL;
            m_refSampleId = MP4_INVALID_SAMPLE_ID;
            m_refSampleOffset = 0;
        }

        void MP4RtpSampleData::SetEmbeddedImmediate(MP4SampleId sampleId,
                uint8_t *pData, uint16_t dataLength)
        {
            ((MP4Integer8Property *)m_pProperties[1])->SetValue((uint8_t) - 1);
            ((MP4Integer16Property *)m_pProperties[2])->SetValue(dataLength);
            ((MP4Integer32Property *)m_pProperties[3])->SetValue(sampleId);
            ((MP4Integer32Property *)m_pProperties[4])->SetValue(0);
            CHECK_AND_FREE(m_pRefData);
            m_pRefData = pData;
        }

        void MP4RtpSampleData::SetReferenceSample(
            MP4SampleId refSampleId, uint32_t refSampleOffset,
            uint16_t sampleLength)
        {
            ((MP4Integer8Property *)m_pProperties[1])->SetValue(0);
            ((MP4Integer16Property *)m_pProperties[2])->SetValue(sampleLength);
            ((MP4Integer32Property *)m_pProperties[3])->SetValue(refSampleId);
            ((MP4Integer32Property *)m_pProperties[4])->SetValue(refSampleOffset);
        }

        void MP4RtpSampleData::SetEmbeddedSample(
            MP4SampleId sampleId, MP4Track *pRefTrack,
            MP4SampleId refSampleId, uint32_t refSampleOffset,
            uint16_t sampleLength)
        {
            ((MP4Integer8Property *)m_pProperties[1])->SetValue((uint8_t) - 1);
            ((MP4Integer16Property *)m_pProperties[2])->SetValue(sampleLength);
            ((MP4Integer32Property *)m_pProperties[3])->SetValue(sampleId);
            ((MP4Integer32Property *)m_pProperties[4])->SetValue(0);
            m_pRefTrack = pRefTrack;
            m_refSampleId = refSampleId;
            m_refSampleOffset = refSampleOffset;
        }

        uint16_t MP4RtpSampleData::GetDataSize()
        {
            return ((MP4Integer16Property *)m_pProperties[2])->GetValue();
        }

        void MP4RtpSampleData::GetData(uint8_t *pDest)
        {
            uint8_t trackRefIndex =
                ((MP4Integer8Property *)m_pProperties[1])->GetValue();

            MP4Track *pSampleTrack =
                FindTrackFromRefIndex(trackRefIndex);

            pSampleTrack->ReadSampleFragment(
                ((MP4Integer32Property *)m_pProperties[3])->GetValue(), // sampleId
                ((MP4Integer32Property *)m_pProperties[4])->GetValue(), // sampleOffset
                ((MP4Integer16Property *)m_pProperties[2])->GetValue(), // sampleLength
                pDest);
        }

        void MP4RtpSampleData::WriteEmbeddedData(MP4File &file, uint64_t startPos)
        {
            // if not using embedded data, nothing to do
            if (((MP4Integer8Property *)m_pProperties[1])->GetValue() != (uint8_t) - 1)
            {
                return;
            }

            // figure out the offset within this hint sample for this embedded data
            uint64_t offset = file.GetPosition() - startPos;
            ASSERT(offset <= 0xFFFFFFFF);
            ((MP4Integer32Property *)m_pProperties[4])->SetValue((uint32_t)offset);

            uint16_t length = ((MP4Integer16Property *)m_pProperties[2])->GetValue();

            if (m_pRefData)
            {
                file.WriteBytes(m_pRefData, length);
                return;
            }

            if (m_refSampleId != MP4_INVALID_SAMPLE_ID)
            {
                uint8_t *pSample = NULL;
                uint32_t sampleSize = 0;

                ASSERT(m_pRefTrack);
                m_pRefTrack->ReadSample(m_refSampleId, &pSample, &sampleSize);

                ASSERT(m_refSampleOffset + length <= sampleSize);

                file.WriteBytes(&pSample[m_refSampleOffset], length);

                MP4Free(pSample);
                return;
            }
        }

        MP4RtpSampleDescriptionData::MP4RtpSampleDescriptionData(MP4RtpPacket &packet)
            : MP4RtpData(packet)
        {
            ((MP4Integer8Property *)m_pProperties[0])->SetValue(3);

            AddProperty( /* 1 */
                new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "trackRefIndex"));
            AddProperty( /* 2 */
                new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "length"));
            AddProperty( /* 3 */
                new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleDescriptionIndex"));
            AddProperty( /* 4 */
                new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleDescriptionOffset"));
            AddProperty( /* 5 */
                new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "reserved"));
        }

        void MP4RtpSampleDescriptionData::Set(uint32_t sampleDescrIndex,
                                              uint32_t offset, uint16_t length)
        {
            ((MP4Integer16Property *)m_pProperties[2])->SetValue(length);
            ((MP4Integer32Property *)m_pProperties[3])->SetValue(sampleDescrIndex);
            ((MP4Integer32Property *)m_pProperties[4])->SetValue(offset);
        }

        uint16_t MP4RtpSampleDescriptionData::GetDataSize()
        {
            return ((MP4Integer16Property *)m_pProperties[2])->GetValue();
        }

        void MP4RtpSampleDescriptionData::GetData(uint8_t *pDest)
        {
            // we start with the index into our track references
            uint8_t trackRefIndex =
                ((MP4Integer8Property *)m_pProperties[1])->GetValue();

            // from which we can find the track structure
            MP4Track *pSampleTrack =
                FindTrackFromRefIndex(trackRefIndex);

            // next find the desired atom in the track's sample description table
            uint32_t sampleDescrIndex =
                ((MP4Integer32Property *)m_pProperties[3])->GetValue();

            MP4Atom &trakAtom =
                pSampleTrack->GetTrakAtom();

            char sdName[64];
            snprintf(sdName, 64, "trak.mdia.minf.stbl.stsd.*[%u]", sampleDescrIndex);

            MP4Atom *pSdAtom =
                trakAtom.FindAtom(sdName);

            // bad reference
            if (pSdAtom == NULL)
            {
                throw new Exception("invalid sample description index", __FILE__, __LINE__, __FUNCTION__ );
            }

            // check validity of the upcoming copy
            uint16_t length =
                ((MP4Integer16Property *)m_pProperties[2])->GetValue();
            uint32_t offset =
                ((MP4Integer32Property *)m_pProperties[4])->GetValue();

            if (offset + length > pSdAtom->GetSize())
            {
                throw new Exception("offset and/or length are too large",
                                    __FILE__, __LINE__, __FUNCTION__);
            }

            // now we use the raw file to get the desired bytes

            MP4File &file = GetPacket().GetHint().GetTrack().GetFile();

            uint64_t orgPos = file.GetPosition();

            // It's not entirely clear from the spec whether the offset is from
            // the start of the sample descirption atom, or the start of the atom's
            // data. I believe it is the former, but the commented out code will
            // realize the latter interpretation if I turn out to be wrong.
            uint64_t dataPos = pSdAtom->GetStart();
            //uint64_t dataPos = pSdAtom->GetEnd() - pSdAtom->GetSize();

            file.SetPosition(dataPos + offset);

            file.ReadBytes(pDest, length);

            file.SetPosition(orgPos);
        }

        ///////////////////////////////////////////////////////////////////////////////

    }
} // namespace mp4v2::impl
